package org.ailoli.aixiang.utils

import android.graphics.Bitmap
import android.text.TextUtils
import android.util.Log
import com.google.zxing.BarcodeFormat
import com.google.zxing.EncodeHintType
import com.google.zxing.WriterException
import com.google.zxing.qrcode.QRCodeWriter
import java.util.*
import kotlin.experimental.xor


class Utils {

    companion object{

        //-------------------------------------------------------
        // 判断奇数或偶数，位运算，最后一位是1则为奇数，为0是偶数
        fun isOdd(num: Int): Int {
            return num and 1
        }

        //-------------------------------------------------------
        //Hex字符串转int
        fun HexToInt(inHex: String): Int {
            return inHex.toInt(16)
        }

        fun IntToHex(intHex: Int): String? {
            return Integer.toHexString(intHex)
        }

        //-------------------------------------------------------
        //Hex字符串转byte
        fun HexToByte(inHex: String): Byte {
            return inHex.toInt(16).toByte()
        }

        //-------------------------------------------------------
        //1字节转2个Hex字符
        fun Byte2Hex(inByte: Byte): String? {
            return String.format("%02x", *arrayOf<Any>(inByte)).toUpperCase()
        }

        //-------------------------------------------------------
        //字节数组转转hex字符串
        fun ByteArrToHex(inBytArr: ByteArray): String? {
            val strBuilder = StringBuilder()
            for (valueOf in inBytArr) {
                strBuilder.append(Byte2Hex(java.lang.Byte.valueOf(valueOf)))
                strBuilder.append(" ")
            }
            return strBuilder.toString()
        }

        //-------------------------------------------------------
        //字节数组转转hex字符串，可选长度
        fun ByteArrToHex(inBytArr: ByteArray, offset: Int, byteCount: Int): LinkedList<String>? {
//        fun ByteArrToHex(inBytArr: ByteArray, offset: Int, byteCount: Int): String? {
            val sArray: LinkedList<String>? = LinkedList()
            val strBuilder = StringBuilder()
            for (i in offset until byteCount) {
                sArray!!.add(Byte2Hex(java.lang.Byte.valueOf(inBytArr[i])).toString())
                strBuilder.append(Byte2Hex(java.lang.Byte.valueOf(inBytArr[i])))
            }
            return sArray
//            return strBuilder.toString()
        }

        //-------------------------------------------------------
        //转hex字符串转字节数组
        fun HexToByteArr(inHex: String): ByteArray? {
            var inHex = inHex.replace("\\s".toRegex(),"")
            val result: ByteArray
            var hexlen = inHex.length
            if (isOdd(hexlen) == 1) {
                hexlen++
                result = ByteArray(hexlen / 2)
                inHex = "0$inHex"
            } else {
                result = ByteArray(hexlen / 2)
            }
            var j = 0
            var i = 0
            while (i < hexlen) {
                result[j] = HexToByte(inHex.substring(i, i + 2))
                j++
                i += 2
            }
            return result
        }

        /**
         * 按照指定长度切割字符串
         *
         * @param inputString 需要切割的源字符串
         * @param length      指定的长度
         * @return
         */
        fun getDivLines(inputString: String, length: Int): List<String>? {
            val divList: MutableList<String> = ArrayList()
            val remainder = inputString.length % length
            // 一共要分割成几段
            val number = Math.floor((inputString.length / length).toDouble()).toInt()
            for (index in 0 until number) {
                val childStr = inputString.substring(index * length, (index + 1) * length)
                divList.add(childStr)
            }
            if (remainder > 0) {
                val cStr = inputString.substring(number * length, inputString.length)
                divList.add(cStr)
            }
            return divList
        }

        /**
         * 计算长度，两个字节长度
         *
         * @param val value
         * @return 结果
         */
        fun twoByte(`val`: String): String? {
            var `val` = `val`
            if (`val`.length > 4) {
                `val` = `val`.substring(0, 4)
            } else {
                val l = 4 - `val`.length
                for (i in 0 until l) {
                    `val` = "0$`val`"
                }
            }
            return `val`
        }

        /**
         * 校验和
         *
         * @param cmd 指令
         * @return 结果
         */
        fun sum(cmd: String): String? {
            var cmd = cmd
            val cmdList: List<String>? = Utils.getDivLines(cmd, 2)
            var sumInt = 0
            for (c in cmdList!!) {
                sumInt += Utils.HexToInt(c)
            }
            var sum: String? = Utils.IntToHex(sumInt)
            sum = Utils.twoByte(sum!!)
            cmd += sum
            return cmd.toUpperCase()
        }


        /**
         * 亦或校验
         *
         * @param datas
         * @return
         */
        fun getXor(datas: ByteArray): Byte {
            var temp = datas[0]
            for (i in 1 until datas.size) {
                temp = temp xor datas[i]
            }
            return temp
        }

        /**
         * 生成简单二维码
         *
         * @param content                字符串内容
         * @param width                  二维码宽度
         * @param height                 二维码高度
         * @param character_set          编码方式（一般使用UTF-8）
         * @param error_correction_level 容错率 L：7% M：15% Q：25% H：35%
         * @param margin                 空白边距（二维码与边框的空白区域）
         * @param color_black            黑色色块
         * @param color_white            白色色块
         * @return BitMap
         */
        fun createQRCodeBitmap(
            content: String?, width: Int, height: Int,
            character_set: String?, error_correction_level: String?,
            margin: String?, color_black: Int, color_white: Int
        ): Bitmap? {
            // 字符串内容判空
            if (TextUtils.isEmpty(content)) {
                return null
            }
            // 宽和高>=0
            return if (width < 0 || height < 0) {
                null
            } else try {
                /** 1.设置二维码相关配置  */
                val hints: Hashtable<EncodeHintType, String?> = Hashtable()
                // 字符转码格式设置
                if (!TextUtils.isEmpty(character_set)) {
                    hints.put(EncodeHintType.CHARACTER_SET, character_set)
                }
                // 容错率设置
                if (!TextUtils.isEmpty(error_correction_level)) {
                    hints.put(EncodeHintType.ERROR_CORRECTION, error_correction_level)
                }
                // 空白边距设置
                if (!TextUtils.isEmpty(margin)) {
                    hints.put(EncodeHintType.MARGIN, margin)
                }
                /** 2.将配置参数传入到QRCodeWriter的encode方法生成BitMatrix(位矩阵)对象  */
                val bitMatrix =
                    QRCodeWriter().encode(content, BarcodeFormat.QR_CODE, width, height, hints)

                /** 3.创建像素数组,并根据BitMatrix(位矩阵)对象为数组元素赋颜色值  */
                val pixels = IntArray(width * height)
                for (y in 0 until height) {
                    for (x in 0 until width) {
                        //bitMatrix.get(x,y)方法返回true是黑色色块，false是白色色块
                        if (bitMatrix[x, y]) {
                            pixels[y * width + x] = color_black //黑色色块像素设置
                        } else {
                            pixels[y * width + x] = color_white // 白色色块像素设置
                        }
                    }
                }
                /** 4.创建Bitmap对象,根据像素数组设置Bitmap每个像素点的颜色值,并返回Bitmap对象  */
                val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
                bitmap.setPixels(pixels, 0, width, 0, 0, width, height)
                bitmap
            } catch (e: WriterException) {
                e.printStackTrace()
                null
            }
        }
    }

}